home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 1998 September / Macworld (1998-09).dmg / Shareware World / Info / For Developers / MacZoop 1.8.3 / Required Classes / Z Headers / ZMenuBar.h < prev    next >
Text File  |  1998-06-29  |  8KB  |  284 lines
  1. /*************************************************************************************************
  2. *
  3. *
  4. *            MacZoop - "the framework for the rest of us"         
  5. *
  6. *
  7. *
  8. *            ZMenuBar.h            -- the menubar manager object
  9. *
  10. *
  11. *
  12. *
  13. *
  14. *            © 1996, Graham Cox
  15. *
  16. *
  17. *
  18. *
  19. *************************************************************************************************/
  20.  
  21.  
  22. #pragma once
  23.  
  24. #ifndef __ZMENUBAR__
  25. #define    __ZMENUBAR__
  26.  
  27. #include    "ZComrade.h"
  28. #include    "TextStyleUtils.h"
  29. #include    <Menus.h>
  30.  
  31. class    ZArray;
  32.  
  33. // structure for storing info about a menu command
  34.  
  35. typedef struct
  36. {
  37.     long        theCmd;            // item's command
  38.     short        menuID;            // menu ID
  39.     short        itemID;            // item index
  40.     short         cmdFlags;        // associated command flags
  41.     short        subMenuID;        // if parent of submenu, menu we "own".
  42.     MenuHandle    macMenu;        // actual handle of menu that owns this command
  43. }
  44. MenuCmd;
  45.  
  46. // dimming options for entire menus:
  47.  
  48. enum
  49. {
  50.     neverDim = 0,
  51.     dimCommands = 1,
  52.     dimParentItems = 2,
  53.     dimOthers = 4,
  54.     dimAll = 8,
  55.     dimTitle = 32
  56. };
  57.  
  58. typedef unsigned char DimmingOptions;
  59.  
  60.  
  61. // structure for storing info about a whole menu:
  62.  
  63. typedef struct
  64. {
  65.     short            menuID;            // menu ID of the menu
  66.     short            mIndex;            // index into original MBAR resource
  67.     MenuHandle        macMenu;        // handle to the menu
  68.     DimmingOptions    mDimming;        // dimming flags
  69.     Boolean            mIsResource;    // TRUE if menu is a resource
  70. }
  71. MenuInfRec;
  72.  
  73. #if PRAGMA_ALIGN_SUPPORTED
  74. #pragma options align=mac68k
  75. #endif
  76.  
  77. // structure of CMNU resource:
  78.  
  79. typedef struct
  80. {
  81.     short            menuID;
  82.     long            fill1;
  83.     short            procID;
  84.     short            fill2;
  85.     unsigned long    flags;
  86.     char            mTitle;
  87. }
  88. CMNUResource, *CMNUResPtr, **CMNUResHdl;
  89.  
  90. // the items in the menu follow after the title, given the length of the title as
  91. // a number of bytes to skip forward. Each entry consists of the command item text
  92. // followed immediately by four bytes, <icon>, <key equiv>, <mark char>, <style>, 
  93. // followed by command ID (long), followed by next item.
  94.  
  95. typedef struct
  96. {
  97.     unsigned char    iconID;
  98.     unsigned char    keyEqu;
  99.     unsigned char    markChar;
  100.     unsigned char    iStyle;
  101. }
  102. CMNUEntry, *CMNUEntryPtr;
  103.  
  104. // structures used by low-level Mac menu manager:
  105.  
  106. typedef struct
  107. {
  108.     MenuHandle    theMenu;
  109.     short        leftEdge;
  110. }
  111. mListEntry;
  112.  
  113.  
  114. typedef struct
  115. {
  116.     short        lastMOffset;
  117.     short        lastRightEdge;
  118.     short        spare;
  119.     mListEntry    mListItem[1];
  120. }
  121. mList, *mListPtr, **mListHdl;
  122.  
  123.  
  124. #if PRAGMA_ALIGN_SUPPORTED
  125. #pragma options align=reset
  126. #endif
  127.  
  128. // cmd flags
  129.  
  130. enum
  131. {
  132.     nothingSpecial = 0,
  133.     disableCmdsOnly = 1,
  134.     disableAll = 2,
  135.     disableParentItems = 4,
  136.     isPrimaryMenu = 8,
  137.     autoUnCheck = 16,
  138.     menuIsResource = 32
  139. };
  140.  
  141. // special commands
  142.  
  143. enum
  144. {
  145.     noCommand = 0,
  146.     parentCmd = 99
  147. };
  148.  
  149. // constants for AppendStdItems
  150.  
  151. enum
  152. {
  153.     appendDANames = 0,
  154.     appendFontNames
  155. };
  156.  
  157. // constants for menu hiding:
  158.  
  159. typedef enum
  160. {
  161.     MBAR_SHOW,                        // show the menubar
  162.     MBAR_HIDE,                        // hide the menubar
  163.     MBAR_HIDE_MOUSEAWARE            // hide the menu bar unless mouse within 20 pixels of screen top
  164. }
  165. MBarHiding;
  166.  
  167.  
  168.  
  169.  
  170. DEFINECLASSID( ZMenuBar, 'zmbr' );
  171.  
  172. // menubar manager class
  173.  
  174. class    ZMenuBar : public ZComrade
  175. {
  176. protected:
  177.     short            mBarID;                // res ID of original MBAR resource
  178.     short            mbCount;            // number of items in main bar at top level
  179.     short            miSeed;                // index counter
  180.     short            mHelpOffset;        // count of items in help menu before we added any
  181.     short**            mBarH;                // Handle to menubar data during construction
  182.     ZArray*            theMenuCmds;        // array of MenuCmd structs used to map commands
  183.     ZArray*            theMenus;            // array of MenuInfRec structs for menu behaviours
  184.     char            menuCheckChar;        // character used for checking a menu item
  185.     short            wmMenuID;            // ID of windows menu
  186.     short            mBarHeight;            // saved menubar height when hidden
  187.     MBarHiding        mbHiding;            // menubar hiding behaviour
  188.     Boolean            rbPending;            // TRUE if menubar redraw called during dispatch
  189.     Boolean            inDispatch;            // TRUE if currently in dispatch
  190.  
  191. public:
  192.     
  193.     ZMenuBar( const short barID ) : ZComrade() { classID = CLASS_ZMenuBar; mBarID = barID; };
  194.     virtual ~ZMenuBar();
  195.     
  196.     virtual void        InitMenuBar();
  197.     
  198.     virtual void        UpdateMenuBar();
  199.     virtual void        ClickMenuBar( const Point mousePt );
  200.     virtual void        DispatchCommand( const long mSelect );
  201.     virtual void        DimMenus();
  202.     
  203.     virtual void        EnableCommand( const long cmd );
  204.     virtual void        EnableCommand( const short menuID, const short itemID );
  205.     virtual void        DisableCommand( const long cmd );
  206.     virtual void        DisableCommand( const short menuID, const short itemID );
  207.     
  208.     virtual void        CheckCommand( const long cmd, const Boolean checkOnOff );
  209.     virtual void        CheckCommand( const short menuID, const short itemID, const Boolean checkOnOff );
  210.     virtual void        CheckCommand( const short menuID, Str255 itemString, const Boolean checkOnOff );
  211.     virtual void        CheckCommandWithChar( const long cmd, const char checkChar );
  212.     virtual void        CheckCommandWithChar( const short menuID, Str255 itemString, const char checkChar );
  213.     virtual void        SetCommandText( const long cmd, Str255 aText );
  214.     virtual void        SetCommandText( const short menuID, const short itemID, Str255 aText );
  215.     virtual void        SetCommandText( const long cmd, const short strListID, const short strIndex );
  216.     virtual void        SetCommandText( const short menuID, const short itemID, const short strListID, const short strIndex );
  217.     
  218.     virtual void        SetCommandTextStyle( const long cmd, Style aStyle );
  219.     
  220.     virtual void        SetTitleHilite( const short menuID, const Boolean state );
  221.     virtual void        SetMenuDimming( const short menuID, const DimmingOptions dimOpts );
  222.     
  223.     virtual void        AppendMenuToBar( const short menuID );
  224.     virtual void        RemoveMenuFromBar( const short menuID );
  225.     virtual void        AppendStdItems( const short menuID, const short iType = appendDANames );
  226.     virtual MenuHandle    FindMenuID( const short menuID );
  227.     
  228.     virtual short        AppendHelpItem( Str255 itemText );    
  229.     
  230. // automatic "windows" menu handling:
  231.  
  232.     virtual void        NominateWindowsMenu( const short menuID );    
  233.     
  234.     inline    void        SetCheckMarkChar( const char aChar ) { menuCheckChar = aChar; };
  235.     inline  char        GetCheckMarkChar() { return menuCheckChar; };
  236.     
  237. // font, style and size menu utilities, can be called from any UpdateMenus():
  238.  
  239.     virtual void        UpdateStyleMenu( TEStyleRunInfo* runInfo );
  240.     virtual void        UpdateFontSizeMenu( TEStyleRunInfo* runInfo );
  241.     
  242. // showing and hiding the menubar:
  243.  
  244.     virtual void        ShowHideMenuBar( MBarHiding    mHiding, Point gMouseLoc );
  245.     virtual void        ShowHideMenuBar( MBarHiding    mHiding );
  246.     inline    MBarHiding    GetMenuBarVisState() { return mbHiding; };
  247.     
  248.     virtual void        SetZoomSourceToCommand( const long aCmd );
  249. protected:
  250.     
  251.     virtual void        LoadMenus( const Boolean autoInstall = TRUE );
  252.     
  253.     virtual void        LoadMenu( const short menuID, Boolean isHMenu = FALSE, Boolean autoInstall = TRUE );
  254.     virtual void        LoadCMNUMenu( const short menuID, Boolean isHMenu = FALSE, Boolean autoInstall = TRUE );
  255.     virtual void        UnloadMenu( MenuHandle mH );
  256.     virtual void        PredimMenu( MenuHandle theMenu );
  257.     virtual void        ParseMenuItem( Str255 iText, long* aCmd ); 
  258.     
  259.     virtual void        FindMCmd( const long mSelect, MenuCmd* aCmd );
  260.     virtual void        FindCommand( const long cmd, short* menuID, short* itemID );
  261.  
  262.     virtual long        TrackMenuBar( const Point mouse );
  263.     virtual void        FindMenuInfo( const short menuID, MenuInfRec* mRec );
  264.     virtual void        GetMenuTitleRect( short menuID, Rect* tRect );    
  265. };
  266.  
  267.  
  268. // this object handles a menubar. By default, it calls the mac menu manager to work with the
  269. // global menubar at the top of the main monitor, but it can be subclassed to implement other
  270. // sorts of menubar, for example a mini-menubar in a window (this is left as an exercise!).
  271. // This loads menus and parses the items into a list of command IDs. When the menu item is
  272. // chosen, the associated command is looked up. This is then generally passed up the command
  273. // chain in force at the time.
  274.  
  275. // commands are associated initially with menu items using a #character, so your TCL resources
  276. // etc. can be used directly with this. e.g. "Open File...#12345" will result in the menu item
  277. // "Open File..." and the command number 12345. This will also use CMNU resources (a la MacApp)
  278. // if it can't find a MENU resource. Thus you get the best of both worlds!
  279.  
  280.  
  281. extern    ZMenuBar*    gMenuBar;
  282. extern    short        gFontMenuID;
  283.  
  284. #endif